Multiple user interfaces of an artificial intelligence system to accommodate different types of users solving different types of problems with artificial intelligence

ABSTRACT

Provided herein in some embodiments is an artificial intelligence (“AI”) engine configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The AI engine can include AI-engine modules including an architect module, an instructor module, and a learner module. An assembly code can be generated from a source code written in a pedagogical programming language. The architect module can be configured to propose a neural-network layout from the assembly code; the learner module can be configured to build the AI model from the neural-network layout; and the instructor module can be configured to train the AI model built by the learner module. The multiple user interfaces can include an integrated development environment, a web-browser interface, or a command-line interface configured to enable an author to define a mental model for the AI model to learn.

NOTICE OF COPYRIGHT

A portion of this disclosure contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the material subject to copyright protection as it appears in the United States Patent & Trademark Office's patent file or records, but otherwise reserves all copyright rights whatsoever.

CROSS-REFERENCE

This application claims priority to U.S. Provisional Patent Application No. U.S. 62/287,861, filed Jan. 27, 2016, titled “BONSAI PLATFORM, LANGUAGE, AND TOOLING,” the disclosure of which is hereby incorporated herein by reference in its entirety.

FIELD

Embodiments of the design provided herein generally relate to artificial intelligence systems and methods thereof.

BACKGROUND

Artificial intelligence (“AI”) has potential to be one of the most impactful technologies of the 21^(st) century and beyond. Unfortunately, software developers currently looking to work with AI must learn complex toolkits, use limited application programming interfaces (“APIs”), use constrained black-box solutions for AI, or some combination thereof. The foregoing limitations must be overcome for software developers and enterprises to solve real-world problems with AI. In addition, with fewer than 20,000 data science experts capable of building AI at its lowest levels, working with AI needs to be made more accessible to the 20 million or more software developers of the software development community. Provided herein are AI systems and methods that address the foregoing.

SUMMARY

Provided herein in some embodiments is an AI engine configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The AI engine can include one or more AI-engine modules including an architect module, an instructor module, and a learner module. A compiler can be configured to receive a source code written in a pedagogical programming language through an API exposed to the multiple user interfaces. The compiler can be further configured to generate an assembly code from the source code. The architect module can be configured to propose a neural-network layout with one or more neural-network layers from the assembly code. The learner module can be configured to build the AI model with the one or more neural-network layers from the neural-network layout proposed by the architect module. The instructor module can be configured to train the AI model built by the learner module. The multiple user interfaces enable an author to define a mental model for the AI model to learn and one or more curriculums written in the pedagogical programming language, the mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output. The multiple user interfaces can further enable the author to send the source code through the API exposed to the multiple user interfaces to the compiler.

Also provided herein in some embodiments is an AI system including an AI engine configured with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The AI system can include one or more remote servers and one or more local clients. The one or more remote servers can include a compiler and one or more AI-engine modules including an architect module, an instructor module, and a learner module. The compiler can be configured to receive a source code written in a pedagogical programming language through an API exposed to the multiple user interfaces. The compiler can be further configured to generate an assembly code from the source code. The architect module can be configured to propose a neural-network layout with one or more neural-network layers from the assembly code. The learner module can be configured to build the AI model with the one or more neural-network layers from the neural-network layout proposed by the architect module. The instructor module can be configured to train the AI model built by the learner module. The one or more local clients can include the multiple user interfaces. The multiple user interfaces enable an author to define a mental model for the AI model to learn and one or more curriculums written in the pedagogical programming language, the mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output. Each user interface of the multiple user interfaces can be selected from an integrated development environment (“IDE”), a web-browser interface, and a command-line interface (“CLI”). The multiple user interfaces can further enable the author to send the source code through the API exposed to the multiple user interfaces to the compiler.

Also provided herein in some embodiments is a method for an AI system configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The method can include receiving a source code, generating an assembly code from the source code, proposing a neural-network layout from the assembly code, building an AI model from the neural-network layout, and training the AI model. Receiving the source code can include receiving the source code through an API exposed to the multiple user interfaces. Generating the assembly code can include generating the assembly code from the source code with a compiler of an AI engine configured to work with the multiple interfaces. Proposing the neural-network layout can include proposing the neural-network layout including one or more neural-network layers from the assembly code with an architect AI-engine module of the AI engine. Building the AI model can include building the AI model including the one or more neural-network layers from the neural-network layout with a learner AI-engine module of the AI engine. Training the AI model can include training the AI model on the mental model with an instructor AI-engine module of the AI engine. The method can further include enabling an author to define a mental mode and send the source code with the mental model through the API exposed to the multiple user interfaces. Enabling the author to define the mental model can include enabling the author to define the mental model for the AI model to learn and one or more curriculums written in a pedagogical programming language, the mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output.

These and other features of the design provided herein can be better understood with reference to the drawings, description, and claims, all of which form the disclosure of this patent application.

DRAWINGS

The drawings refer to some embodiments of the design provided herein in which:

FIG. 1A provides a schematic illustrating a simple artificial neural network.

FIG. 1B provides a schematic illustrating building, training, and deploying a trained AI model in accordance with some embodiments.

FIG. 2A provides a schematic illustrating an AI system in accordance with some embodiments.

FIG. 2B provides a schematic illustrating an AI system including multiple interfaces in accordance with some embodiments.

FIG. 2C provides a schematic illustrating a method associated with an AI system in accordance with some embodiments.

FIG. 3A provides a schematic illustrating an AI system in accordance with some embodiments.

FIG. 3B provides a schematic illustrating a method associated with an AI system in accordance with some embodiments.

FIG. 4A provides an image of an IDE including a textual editor in accordance with some embodiments.

FIG. 4B provides an image of an IDE including a textual editor in accordance with some embodiments.

FIG. 4C provides an image of an IDE including a graphical editor in accordance with some embodiments.

FIG. 4D provides an image of an IDE including a graphical editor in accordance with some embodiments.

FIG. 4E provides an image of an IDE including a graphical display of a mental model and a corresponding neural network's performance in learning the mental model in accordance with some embodiments.

FIG. 4F provides an image of an IDE including a training-data source and training data in accordance with some embodiments.

FIG. 4G provides an image of an IDE including a deploy action in accordance with some embodiments.

FIG. 4H provides a schematic of a web-browser interface in accordance with some embodiments.

FIG. 4I provides a schematic of a web-browser interface including a visualization of training progress in accordance with some embodiments.

FIG. 4J provides a schematic of a CLI in accordance with some embodiments.

FIG. 5A provides a schematic illustrating a mental model including a concept in accordance with some embodiments.

FIG. 5B provides a schematic illustrating a mental model including a number of concepts in accordance with some embodiments.

FIG. 6 provides a schematic illustrating an AI system in accordance with some embodiments.

FIG. 7A provides a schematic illustrating an AI system in accordance with some embodiments.

FIG. 7B provides a schematic illustrating an AI system in accordance with some embodiments.

FIG. 8 provides one or more networks in accordance with some embodiments.

FIG. 9 provides one or more computing systems in accordance with some embodiments.

While the design is subject to various modifications, equivalents, and alternative forms, specific embodiments thereof have been shown by way of example in the drawings and will now be described in detail. It should be understood that the design is not limited to the particular embodiments disclosed, but—on the contrary—the intention is to cover all modifications, equivalents, and alternative forms using the specific embodiments.

DESCRIPTION

In the following description, numerous specific details are set forth, such as examples of specific data signals, named components, memory in a device, etc., in order to provide a thorough understanding of the present design. It will be apparent, however, to one of ordinary skill in the art that the present design can be practiced without these specific details. In other instances, well known components or methods have not been described in detail but rather in a block diagram in order to avoid unnecessarily obscuring the present design. Further, specific numeric references such as first driver, can be made. However, the specific numeric reference should not be interpreted as a literal sequential order but rather interpreted that the first notification is different than a second notification. Thus, the specific details set forth are merely exemplary. The specific details can be varied from and still be contemplated to be within the spirit and scope of the present design. The term coupled is defined as meaning connected either directly to the component or indirectly to the component through another component.

An “AI model” as used herein includes, but is not limited to, neural networks such as recurrent neural networks, recursive neural networks, feed-forward neural networks, convolutional neural networks, deep belief networks, and convolutional deep belief networks; multi-layer perceptrons; self-organizing maps; deep Boltzmann machines; and stacked de-noising auto-encoders.

An “artificial neural network” or simply a “neural network” as used herein can include a highly interconnected network of processing elements, each optionally associated with a local memory. FIG. 1A provides a schematic illustrating a simple artificial neural network 101. The processing elements can be referred to herein as “artificial neural units,” “artificial neurons,” “neural units,” “neurons,” “nodes,” and the like, while connections between the processing elements can be referred to herein as “synapses,” “weights,” and the like. A neuron can receive data from an input or one or more other neurons respectively through one or more weighted synapses, process the data, and send processed data to an output or yet one or more other neurons respectively through one or more other weighted synapses. The neural network or one or more neurons thereof can be generated in either hardware, software, or a combination of hardware and software, and the neural network can be subsequently trained.

As used herein, “remote” and “local” such as in a “remote server” and a “local client” are intended to convey, for example, the remote server and local client are telecommunicatively coupled, sometimes over very large geographic distances. As used herein “online” is intended to convey two systems such as the remote server and the local client are telecommunicatively coupled and available for immediate communications between the two systems. As used herein “offline” is intended to convey two systems such as the remote server and the local client are telecommunicatively coupled but at least one of the two systems is not available for immediate communications between the two systems. For example, at least one of the remote server and the local client can be switched off and, therefore, “offline.” Alternatively, “offline” can indicate two systems such as the remote server and the local client are not telecommunicatively coupled, for example, due to a broken telecommunications connection.

Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by persons of ordinary skill in the art.

AI has potential to be one of the most impactful technologies of the 21^(st) century and beyond. Unfortunately, software developers currently looking to work with AI must learn complex toolkits, use limited APIs, use constrained black-box solutions for AI, or some combination thereof. The foregoing limitations must be overcome for software developers and enterprises to solve real-world problems with AI. In addition, with fewer than 20,000 data science experts capable of building AI at its lowest levels, working with AI needs to be made more accessible to the 20 million or more software developers of the software development community. Provided herein are AI systems and methods that address the foregoing.

For example, provided herein in some embodiments is an AI engine configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The AI engine can include one or more AI-engine modules including an architect module, an instructor module, and a learner module. A compiler can be configured to receive a source code written in a pedagogical programming language through an API exposed to the multiple user interfaces. The compiler can be further configured to generate an assembly code from the source code. The architect module can be configured to propose a neural-network layout with one or more neural-network layers from the assembly code. The learner module can be configured to build the AI model with the one or more neural-network layers from the neural-network layout proposed by the architect module. The instructor module can be configured to train the AI model built by the learner module. The multiple user interfaces enable an author to define a mental model for the AI model to learn and one or more curriculums written in the pedagogical programming language, the mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output. The multiple user interfaces can further enable the author to send the source code through the API exposed to the multiple user interfaces to the compiler.

FIG. 1B provides a schematic illustrating building, training, and deploying a trained AI model in accordance with some embodiments.

As shown, AI systems and methods provided herein enable users such as software developers to design an AI model, build the AI model, train the AI model to provide a trained AI model, and deploy the trained AI model as a deployed AI model in any of a number of desired ways. For example, AI systems and methods provided herein enable users such as software developers to design a neural network layout or neural network topology 102, build a neural network 104, train the neural network 104 to provide a trained neural network 106, and deploy the trained neural network 106 as a deployed neural network 108 in any of a number of desired ways. For example, the trained AI model or the trained neural network 106 can be deployed in or used with a software application or a hardware-based system.

FIG. 2A provides a schematic illustrating an AI system 200 in accordance with some embodiments.

As shown, the AI system 200 includes one or more client systems 210 and one or more server systems 220, wherein each server system or any two or more servers systems of the one or more server systems 220 can be referred to herein as an AI engine. The one or more client systems 210 can include a client-side client-server interface or client interface 212, which can include a code-generating means for generating programming code, a code-sending means for sending programming code to the AI engine, or both the code-generating means for generating the programming code and the code-sending means for sending the programming code. The programming code can be Inkling™ code, which is based upon the pedagogical programming language Inkling™. The one or more client systems 210 can further include a training data source 219. The training data source 219 can alternatively be included in the one or more server systems 220 as shown in FIG. 2B, or the training data source 219 can be include in both the one or more client systems 210 and the one or more server systems 220. The one or more server systems 220 can include an API 221 exposed to the client interface 212 for receiving the programming code, a compiler 222 for the code, and an AI generator 223 for generating the trained neural network 106 via one or more training cycles in the AI generator 223.

FIG. 2B provides a schematic illustrating an AI system including multiple interfaces in accordance with some embodiments.

Following on the AI system 200 of FIG. 2A, the client interface 212 can include an integrated development environment (“IDE”) 214 for a pedagogical programming language, a web-browser interface 216, or a command-line interface (“CLI”) 218 as shown in FIG. 2B. The IDE 214 can include the code-generating means for generating the programming code, and the IDE 214 can further include the code-sending means for sending programming code to the AI engine. Alternatively, another IDE not specific to a pedagogical programming language but having a plugin therefor, a text editor native to a client system, or a text editor in the web-browser interface 216 can include the code-generating means, and the web-browser interface 216 or the CLI 218 can include the code-sending means for sending the programming code to the AI engine. The training data source 219 is shown FIG. 2B as part of the one or more server systems 220; however, the training data source 219 can alternatively be included in the one or more client systems 210 as shown in FIG. 2A, or the training data source 219 can be included in both the one or more client systems 210 and the one or more server systems 220. Again, the one or more server systems 220 can include the programming code-receiving API 221 exposed to the client interface 212.

FIG. 2C provides a schematic illustrating a method 201 associated with an AI system in accordance with some embodiments.

In view of FIGS. 2A and 2B, a client such as a client of the one or more clients 210 can send code from the client interface 212 (e.g., the IDE 214, the web-browser interface 216, or the CLI 218) or an intermediate agent through the exposed API 221 to the compiler 222 on a server such as a server of the one or more server systems 220 for compiling the code into an optimized assembly code for the AI generator 223. The compiler 222 can send the compiled code or assembly code to the AI generator 223, which proposes and builds a neural network such as the neural network 104 for training as determined by features of the code. The AI generator can request training data from the training data source 219, and the training data source 219 can send the training data to the AI generator 223 upon the request—each of which can optionally be performed through the API 221. The AI generator 223 can subsequently train the neural network 104 on the training data in one or more training cycles to provide a trained state of the neural network or the trained neural network 106. The AI generator 223 can elicit a prediction from the trained neural network 106 and send the prediction to the training data source 219 for updated training data based upon the prediction and, optionally, additional training cycles. When the one or more training cycles are complete, the AI generator 223 can save the trained state of the neural network as the trained neural network 106.

FIG. 3A provides a schematic illustrating an AI system in accordance with some embodiments.

Following on the AI system 200 of FIGS. 2A and 2B, the AI generator 223 for generating the trained neural network 106 can include one or more AI-generator modules selected from at least an instructor module 324, an architect module 326, and a learner module 328 as shown. The instructor module 324, the architect module 326, and the learner module 328 can respectively be referred to herein as the Instructor, the Architect, and the Learner. The instructor module 324 can optionally include hyperlearner module 325, which can be referred to herein as the Hyperlearner, and which can be configured to select one or more hyperparameters for any one or more of a neural network configuration, a learning algorithm, a learning optimizer, and the like. Before selecting the one or more hyperparameters, the hyperlearner module 325 can access a database of solution statistics gathered from one or more repositories of previous problems and previously built AI models therefor and take a fingerprint of a sample of available data by using random predictions. The hyperlearner module 325 can optionally be contained in a different AI-generator module such as the architect module 326 or the learner module 328, or the hyperlearner module 325 can be an AI-generator module itself. The learner module 328 can optionally include a predictor module 329, which can be referred to herein as the Predictor, and which can provide one or more predictions for a trained neural network such as the trained neural network 106 hosted in a prediction mode. The predictor module 329 can optionally be contained in a different AI-generator module such as the instructor module 324 or the architect module 326, or the predictor module 329 can be an AI-generator module itself. The AI generator 223 including the foregoing one or more AI-generator modules can be configured to generate the trained neural network 106 from compiled code via one or more training cycles in the AI generator 223.

While the one or more client systems 210 can include the training data source 219 as shown in FIG. 3A, the training data source 219 can alternatively be included in the one or more server systems 220 as shown in FIG. 2B, or the training data source 219 can be include in both the one or more client systems 210 and the one or more server systems 220. In addition, the one or more server systems 220 of FIG. 3A can include the programming code-receiving API 221 exposed to the client interface 212 (e.g., the IDE 214, the web-browser interface 216, or the CLI 218).

FIG. 3B provides a schematic illustrating a method associated with an AI system in accordance with some embodiments.

As shown in view of FIG. 3A, a client such as a client of the one or more clients 210 can send code from the client interface 212 (e.g., the IDE 214, the web-browser interface 216, or the CLI 218) or an intermediate agent through the exposed API to the compiler 222 on a server such as server of the one or more server systems 220 for compiling the code into an optimized assembly code. The compiler 222 can send the compiled code or assembly code to the instructor module 324, which, in turn, can send the code to the architect module 326. The architect module 326 can propose a neural network layout such as the neural network layout 102—as well as optimize the neural network layout 102—for building and training as determined by features of the code, and the architect module 326 can send the neural network layout 102 to the instructor module 324. In addition, the architect module 326 can map between one or more concepts or concept nodes of a mental model expressed in a pedagogical programming language and one or more layers of the neural network layout 102 and subsequently send one or more maps to the learner module 328. The learner module 328 can build a neural network such as the neural network 104 from the neural network layout 102 specified by the architect module 326. The instructor module 324 can find a starting point among the one or more concept nodes in the mental model and one or more curriculums expressed in the pedagogical programming language for training the neural network 104. The instructor module 324 can also request training data from the training data source 219 or any additional training data sources, and the training data source 219 (or sources) can send the training data to the instructor module 324 upon the request—each of which can optionally be performed through the API 221. The instructor module 324 can subsequently instruct the learner module 328 on training the neural network 104 (e.g., which lessons should be taught in which order) with the one or more curriculums for training the one or more concepts in the mental mode using the training data and one or more hyperparameters from the hyperlearner module 325. Training the neural network 104 can take place in one or more training cycles with the training data to yield a trained state of the neural network or the trained neural network 106. The instructor module 324 can decide what concepts and streams should be actively trained in an mental model, as well as terminating conditions for training the concepts. The learner module 328 or the predictor module 329 can elicit a prediction from the trained neural network 106 and send the prediction to the instructor module 324. The instructor module 324, in turn, can send the prediction to the training data source 219 for updated training data based upon the prediction and, optionally, instruct the learner module 328 in additional training cycles. When the one or more training cycles are complete, the learner module 328 can save the trained state of the neural network as the trained neural network 106.

Client-Server Interfaces

The AI system provided herein can include one or more client-side client-server interfaces and one or more server-side client-server interfaces configured to cooperate or communicate with each other such that one or more users can work online with a server including the AI engine. The one or more client-server interfaces such as the client interface 212 of FIGS. 2A and 3A can be selected from graphical interfaces and textual interfaces, which, in turn, reflect the multiple interfaces of the AI system to accommodate different types of users such as those trying to solve different types of problems with AI. The different types of users solving the different types of problems with AI can be users having different levels of programming skills solving different problems with AI at least commensurate with the different levels of programming skills. The IDE 214, the web-browser interface 216, and the CLI 218 can accommodate the users having the different levels of programming skills.

A graphical interface can include the IDE 214 and the web-browser interface 216 of FIG. 2B when the web-browser interface 216 is part of a graphical web browser such as Microsoft Internet Explorer, Microsoft Edge, Mozilla Firefox, Google Chrome, and the like. A textual interface can include the CLI 214 and the web-browser interface 216 of FIG. 2B when the web-browser interface 216 is part a textual web browser such as Lynx, Links, and the like.

Integrated Development Environment

As provided herein, the client interface 212 of FIGS. 2A and 3A can include the IDE 214 of FIG. 2B including the code-generating means for generating the programming code and the code-sending means for sending the programming code to the AI engine. The programming code can be a source code written in a pedagogical programming language. FIGS. 4A-4G provide example images of the IDE 214 in accordance with some embodiments, wherein FIGS. 4A and 4B provide images of the IDE 214 including a text editor for generating the source code for a mental model, FIGS. 4C and 4D provide images of the IDE 214 including a graphical editor for graphically editing a mental model, FIG. 4E provides an image of the IDE 214 including a mental model and a corresponding neural network's performance in learning the mental model, FIG. 4F provides an image of the IDE 214 including a training-data source and training data, and FIG. 4G provides an image of the IDE 214 including a deploy action through a deployment configurator.

As shown in FIGS. 4A-4G, the IDE 214 can be configured as a window with a menu bar 402, a short cut bar 404, a status bar 406, or some combination thereof. The menu bar 402 can be configured to provide IDE-specific, drop-down menus for creating and interacting with AI models, as well more common drop-down menus for opening files, displaying help documentation or manuals, and the like. The short cut bar 404 can be configured to provide short cuts or buttons such as short cuts for creating and interacting with AI models. For example, as shown, the short cut bar 404 can include an “Edit” short cut for accessing a text editor 410 for creating or modifying a source code in a pedagogical programming language defining a mental model; a “Design” short cut for accessing mental-model designer 412 for creating or modifying a mental model; a “Data” short cut for accessing a training-data viewer 414 for viewing training data for a neural network to learn in accordance with a mental model; a “Deploy” short cut for accessing a deployment configurator 416 for configuring and deploying a trained AI model or a trained neural network; and a “Help” short cut for accessing help documentation or manuals. The status bar 406 can be configured to provide a search box for searching in the IDE 214 and other networked systems, and the status bar 406 can include a number of additional short cuts for accessing status-related items such as training status of an AI model through a short cut for “Training Log” or deployment status of an AI model through a short cut for “Deployment Status.”

As further shown in FIGS. 4A-4G, the window of the IDE 214 can include one or more panes or views such as a project pane 418, a mental-model designer pane 420, or a training pane 422. The project pane 418 can include access to project files such as a file including a mental model (e.g., “mnist.mm.ink”), a file including one or more curriculums (e.g., “training.pg.ink”) for respectively training one or more concept nodes of a mental model, or a simulator file (e.g., “curve_simulator.py” and “segments_simulator.py,” both written in Python) for a simulator. The mental-model designer pane 420 can include mental model-building elements such as concept nodes, stream nodes, and blocks that can be dragged from the mental-model designer pane 420, dropped into the mental-model designer 412, and arranged with data-type connectors in the mental-model designer 412. The training pane 422 can include a graphical representation of a trained AI model's performance in the trained AI model's currently trained state as well as a means to investigate predictions of the trained AI model against training or testing data in the AI model's currently trained state.

The IDE 214 is therefore configured to enable an author to define a mental model to be learned by a neural network. The mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output, can be defined in a textual mode in the text editor 410, a graphical mode in the mental-model designer 412, or both the textual mode and the graphical mode. The text editor 410 can be the preferred editor for defining the one or more curriculums for training the neural network respectively on the one or more concept nodes. The text editor 410 can be configured to enable the author to define the mental model by typing in the textual mode, while the mental-model designer 412 can be configured to enable the author to define the mental model by mouse gestures and the like in the graphical mode. Notably, the IDE 214 can be configured such that author-based modifications of the mental model made by the typing in the textual mode are automatically replicated in the mental model as represented in the mental-model designer 412. Likewise, author-based modifications of the mental model by the mouse gestures in the graphical mode are automatically replicated in the mental-model as represented in the text editor 410. Furthermore, the text editor 410 is configured to enable the author to set one or more breakpoints in the source code written in the pedagogical programming language. When the author sets the one or more breakpoints, the mental-model designer 412 is configured to automatically highlight the one or more concept nodes of the mental model corresponding to the one or more breakpoints if the one or more breakpoints are set at the one or more concept nodes.

The IDE 214 is therefore also configured to enable an author to access training data from a training-data source such as through the “Data” short cut; analytical tools for analyzing aspects of training a neural network such as a graphical representation of a trained neural network's performance through the training pane 422; and tools for configuring and deploying a trained neural network through the “Deploy” short cut or the deployment configurator 416. The training pane 422, the mental-model designer 412, or the combination of the training pane 422 and the mental-model designer 112 can be further configured for analyzing aspects of training a neural network such as one or more concept nodes of a neural network currently being trained and estimated training time for a concept node of the neural network, a set of concept nodes of the neural network, or all the concept nodes of the neural network.

The IDE 214 can also be configured to support one or more plug-ins for extended functionality of the IDE 214, wherein the extended functionality of the IDE 214 can include support for programming languages in addition to the pedagogical programming language including, for example, Python; source code management; project management; suggesting one or more concepts of a mental model; suggesting one or more mental models; checking programming syntax; checking programming style; editing assembly code (e.g., TensorFlow); finding software bugs; and themes within the IDE 214. However, such extended functionality can alternatively or additionally be built into the IDE itself without the one or more plug-ins.

Web-Browser Interface

As provided herein, the client interface 212 of FIGS. 2A and 3A can include the web-browser interface 216 of FIG. 2B. The IDE 214 or another IDE not specific to a pedagogical programming language but having a plugin therefor, a text editor native to a client system, or a text editor in the web-browser interface 216 can include the code-generating means, and the web-browser interface 216 can include the code-sending means for sending the programming code to the AI engine.

FIG. 4H provides a schematic of a web-browser interface 216 in accordance with some embodiments.

With respect to the web-based interface 216 of FIG. 4H, the web-browser interface 216 can be, but is not limited to, an open tab or a portion thereof in a web browser, a pop-up window of the web browser, a pop-under window of the web browser, a plugin element of the web browser, or any other web-browser element configured to request and accept input. The web-based interface 216 can include a web browser-based tool configured to access a web site for interfacing with the AI engine. The web-based interface 216 can provide a dashboard from which a user can in all matters related to creating, configuring, training, and analyzing a BRAIN, which can include visualizing the BRAIN's training progress as shown in FIG. 4I, as well as sharing, collaborating, and learning about BRAINs. The web-based interface 216 can enable a user to create a new BRAIN, name the new BRAIN, describe the new BRAIN, provide data storage or a link to such data storage to store data for training or testing the new BRAIN, provide data storage or a link to such data storage to store code the new BRAIN is to execute.

Command Line Interface (“CLI”)

As provided herein, the client interface 212 of FIGS. 2A and 3A can include the CLI 218 of FIG. 2B. The IDE 214 or another IDE not specific to a pedagogical programming language but having an plugin therefor, a text editor native to a client system including a text editor in the CLI 218, or a text editor in the web-browser interface 216 can include the code-generating means, and the CLI 218 can include the code-sending means for sending the programming code to the AI engine.

FIG. 4J provides a schematic of a command-line interface in accordance with some embodiments.

With respect to the CLI 218 of FIG. 4J, the CLI 218 can be, but is not limited to, a command line-based application used in a command-line interpreter such as Bash or cmd.exe. Alternatively, the CLI 218 can include a command line-based application in a web-based interface through, for example, a web browser or a web-browser element thereof, which web browser can be textual or graphical. The command-line interface can be configured to request information through a prompt. The CLI 218 can be particularly useful for automation and connection (e.g., via piping) to other tools.

Some actions that can be performed using the CLI 218 include creating and naming a BRAIN, loading a file written in a pedagogical programming language, training the BRAIN, and connecting the BRAIN to a simulator. For example, the following entry in Inkling™ can create a BRAIN and name the BRAIN “myMountainCarBrain”:

-   -   $ bonsai brain create myMountainCarBrain         For example, the following entry in Inkling™ can load a file for         the foregoing BRAIN (i.e., “myMountainCarBrain”):     -   $ bonsai brain load myMountainCarBrain mountaincar.ink         For example the following in Inkling™ entry can start the         training mode for the foregoing BRAIN.     -   $ bonsai brain train start myMountainCarBrain         For example the following entry in Inkling™ can stop the         training mode for the forgoing BRAIN.     -   $ bonsai brain train stop myMountainCarBrain

Pedagogical Programming

Pedagogical programming focuses on codifying one or more of the following: 1) What are the concepts associated with a problem domain? 2) How do the concepts relate to each other? 3) How does one go about teaching the concepts?

The pedagogical programming language Inkling™ is a special purpose programming language designed to effect a trained AI model using higher-level mental models and concepts to be learned instead of lower-level mechanics for building and teaching (or training) neural networks. Inkling™ is a declarative, strongly typed pedagogical programming language configured to generalize from vast, dynamic AI algorithms that generally require high levels of expertise in machine learning. Source code authored with Inkling™ or the Inkling™ file can contain the higher-level mental models and concepts to be taught to and, thereby, learned by an AI model. The Inkling™ file can also contain curricula and lessons thereof to teach the concepts to be learned by the AI model.

Mental Models and Concepts

FIGS. 5A and 5B provide schematics respectively illustrating mental models 500A and 500B and concepts thereof in accordance with some embodiments.

Beginning with concepts, a concept in Inkling™ can be a software object and/or define something that an AI model or a neural network can be trained on and learn. Once learned, the AI model can provide intelligent output. Every Inkling™ file or program needs at least one concept.

A concept can fall into one of at least two groups: fact and strategy. A fact-type concept can describe a state of one or more things such as an object, a ball, a character, an enemy, a light, a person, or the like. The state can be whether the one or more things are on or off, hot or cold, a number or a letter, or the like. The fact-type concept can also describe a location. A strategy-type concept can reflect a method or a behavior such as “avoid_ghosts,” “keep_the_paddle_under_the_ball,” “don't_run_into_walls,” “turn_lights_off,” “get_high_score,” or the like. Both FIGS. 5A and 5B show mental models including the strategy-type concept “get high score.”

Turning to mental models, a mental model in Inkling™ is also something that an AI model can be trained on and learn. A mental model can include an input, one or more concepts or concept nodes, one or more data transformation streams or stream nodes, and an output, all of which can be structured (e.g., hierarchically, cyclically, etc.) in terms of the one or more concepts and the one or more data transformation streams or stream nodes. A mental model models a problem domain through codification of underlying concepts and their relationships to one another, often starting from relatively simple concepts and building in more complex concepts as needed.

As shown in FIG. 5A, a relatively simple, single-concept mental model can include, for example, a strategy-type concept such as “get_high_score.” The single-concept mental model and the concept thereof can be expressed in Inkling™ as in the following Inkling™ code block, wherein the concept is “get_high_score,” a prediction type for the concept is “classifier,” the concept follows input of the game state to the neural network, and the concept feeds output from the neural network:

concept get_high_score : (PlayerMove)   is classifier   follows input (GameState)   feeds output end “PlayerMove” and “GameState” represent schema references, which, in turn, describe one or more data types. Schemas are described in further detail herein.

As shown in FIG. 5B, a more complex, multi-concept mental model can include a hierarchical structure including, for example, strategy-type concepts such as “keep_paddle_under_ball,” “get_high_score,” and state-type concepts such as “ball_location.” The multi-concept mental model and the concepts thereof can be expressed in Inkling™ as in the following code block, wherein the concepts are “ball_location,” “keep_paddle_under_ball,” and “get_high_score.”

concept ball_location : (Int32 x, Int32 y)   is estimator   follows input (GameState) end concept keep_paddle_under_ball : (PlayerMove)   is classifier   follows ball_location, input (GameState) end concept get_high_score : (PlayerMove)   is classifier   follows keep_paddle_under_ball, input (GameState)   feeds output end Prediction types for the concepts are “estimator” and “classifier,” wherein an estimator is configured to estimate a value from its input, and wherein a classifier is configured to classify from its input. Other prediction types for the concepts can also include, but are not limited to, “predictor” and “goal.”

As further shown in FIG. 5B, a concept in a multi-concept mental model can receive input from other concepts in the mental model, send output to other concepts in the mental model, provide a final output or result output, or a combination thereof. This can be expressed in Inkling™ as in the foregoing code block. For example, the concept “keep_paddle_under_ball” follows the concept “ball_location” and input of the game state to the neural network, and the concept “get_high_score” follows the concept “keep_paddle_under_ball” and the input of the game state to the neural network. In addition, the concept “get_high_score” feeds output from the neural network. Graphically, the foregoing code block yields the hierarchical, multi-concept mental model of FIG. 5B. Addition of more concepts to a mental model can decrease training time for an AI model, as well as enable a trained AI model to give smarter, more accurate predictions from training or testing data fed to the mental model.

The input of a mental model can be data representative of the problem domain such as images of cats and dogs for differentiating between cats and dogs. The output of the mental model can be a solution of the problem domain such as “yes” the first image is of a cat or “no” the first image is not of a cat.

In view of the foregoing, the pedagogical programming language Inkling™ can be configured to enable an author to define each of the one or more concept nodes in a mental model by name; prediction type such as estimator, classifier, predictor, and goal; input; output; and one or more connecting concept nodes in the mental model including leading, input-providing concept nodes and following, output-accepting concept nodes, for example, using the keywords “follows” and “feeds.”

Streams

In addition to one or more concepts, a mental model can further include one or more data transformation streams or stream nodes among the structured one or more concepts. Data can flow into a stream node, be processed, and subsequently sent to other nodes (e.g., concept nodes, stream nodes, or both) in the neural network or output from the neural network.

A stream keyword declares a functional transformation of data. Any valid Language INtegrated Query (“LINQ”) statement can be declared, and, as such, a stream node can operate directly on input data, data from other stream nodes, data from concept nodes, from literals, and from built in functions (for example to return random data or sequence data). For example, the following Inkling™ code block declares a functional transformation of data that is explicitly specified:

Stream Double from   item in input (Int32 x) select   item.x*2 => output (Int32 y) The foregoing Inkling™ code block declares a stream node “Double” that reads a 32-bit signed integer from external input to the neural network, doubles it, and directs the result to any subscribed listeners. The “from” and “=>” (or “into”) clauses are similar to “follows” and “feeds” used for the foregoing one or more concepts, which specify construction of the mental model including the one or more concepts and any streams. The select clause can perform a data transformation, including any functions exposed via one or more system libraries (e.g., computer vision algorithms).

Curricula and Lessons

A curriculum is used to teach a concept to a neural network, and there is at least a 1-way relationship between the curriculum and the concept to be taught. For example, for every specified concept, a curriculum is to be specified to teach the concept. Training data is to be provided to train the neural network on the concept, and the AI engine is to be told whether its understanding of the concept, once taught, is correct or not. A curriculum is analogous to a teacher assigning readings to a student from a book and subsequently testing the student on the readings of the book or the book itself. The ways in which the training data is presented is broken into individual components termed “lessons.” In the book analogy, the book can be the curriculum and the lessons can be individual chapters in the book. Lessons allow the concept to learn bit-by-bit, rather than all at once.

A curriculum definition declares a set of one or more lessons that can be utilized to teach a concept, each of which lessons can be configured to optionally use a different flow of a training data. The curriculum definition specifies which concept this curriculum trains, which simulation should be used with this curriculum, and the objective function used to evaluate the learning system's performance. For example, the following Inkling™ code block declares a curriculum for training the foregoing “get_high_score” concept:

curriculum get_high_score_curriculum   train get_high_score   with simulator breakout_simulator (BreakoutConfig) : (GameState)   objective score # get_high_score lesson(s) specified here end In the foregoing Inkling™ code block, the keyword “curriculum” names the curriculum (e.g., “get_high_score_curriculum”) and declares a set of lessons (see “# get_high_score lesson(s) specified here” comment) used to teach a concept. The keyword “train” indicates the concept by name (e.g., “get_high_score”) that the curriculum is to train; the keyword “with” specifies a subsequent training data-source type (e.g., a simulator, a training-data generator, a training-data database) that should be used with the curriculum followed by the training data-source name (e.g., “breakout_simulator”); and the keyword “objective” specifies an objective function or goal (e.g., score) used to evaluate the neural network's performance and, thus, a termination condition for the concept node to be trained. As such, the “get_high_score_curriculum” trains the concept “get_high_score” using a Breakout simulator named “breakout_simulator,” which simulator can be written in any language (e.g., python). The objective of “get_high_score_curriculum” is to increase the score as much as possible.

In another example, the following Inkling™ code block declares a curriculum for training the foregoing “ball_location” concept:

curriculum ball_location_curriculum   train ball_location   with simulator breakout_simulator (BreakoutConfig) : (GameState)   objective ball_location_distance # ball_location lesson(s) specified here end In the foregoing Inkling™ code block, the keyword “curriculum” names the curriculum (e.g., “ball_location_curriculum”) and declares a set of lessons (see “# ball_location lesson(s) specified here” comment) used to teach a concept. The keyword “train” indicates the concept by name (e.g., “ball_location”) that the curriculum is to train; the keyword “with” specifies a subsequent training data-source type (e.g., a simulator, a training-data generator, a training-data database) that should be used with the curriculum followed by the training data-source name (e.g., “breakout_simulator”); and the keyword “objective” specifies the goal (e.g., ball_location_distance) used to evaluate the neural network's performance and, thus, a termination condition for the concept node to be trained. As such, the “ball_location_curriculum” trains the concept “ball_location” using the Breakout simulator named “breakout_simulator.” In the “ball_location_curriculum,” the “ball_location” concept is trained using a different objective function than the “get_high_score_curriculum,” namely “ball_location_distance,” which measures the distance between the AI model's prediction of the ball location and the actual ball location as calculated inside the simulator's simulation.

In view of the foregoing, the pedagogical programming language Inkling™ can be configured to enable an author to define each of the one or more curriculums by name; the concept node to be trained; training data-source type; training data-source name; one or more lessons of the curriculum for the concept node to be trained; and objective for the concept node to be trained. A termination condition for the objective is detailed further with respect to the one or more lessons of the curriculum.

Going back to the book analogy, the book can be the curriculum and the lessons can be individual chapters in the book. Every curriculum for teaching a concept will have one or more lessons, which lessons are declared within the context of a curriculum (e.g., see foregoing “# get_high_score lesson(s) specified here” and “# ball_location lesson(s) specified here” comments). Lessons give the programmer control over neural-network training. For example, the following Inkling™ code block declares a lesson, namely “score_lesson” for the “get_high_score_curriculum” for training the foregoing “get_high_score” concept:

lesson score_lesson   configure     constrain bricks_percent=0.5,     constrain level=1,     constrain paddle_width=4   until     maximize score For another example, the following Inkling™ code block declares two lessons, namely “no_bricks” and “more_bricks,” for the “ball_location_curriculum” for training the foregoing “ball_location” concept:

lesson no_bricks   configure     constrain bricks_percent=0.5,     constrain level=1,     constrain paddle_width=4   until     minimize ball_location_distance lesson more_bricks follows no_bricks   configure     constrain bricks_percent=0.8,     constrain level=20,     constrain paddle_width=1   until     minimize ball_location_distance

In the foregoing Inkling™ code block for the “score_lesson,” the keyword “lesson” names the lesson (e.g., “score_lesson”) while the keyword “configure” declares a configuration for training data for the lesson, which provides guidance to the instructor module as to how to configure training for the neural network. In this example, the keyword “constrain” constrains schema-defined fields such as “bricks_percent,” “level,” and “paddle width,” wherein “bricks_percent” is limited to 0.5%, “level” is constrained to level 1, and “paddle width” is limited to 4 in the Breakout simulator. The keyword “until” specifies training for the neural network should be continued until the return value for objective function “score” is maximized per the keyword “maximize.” Once training starts, the AI engine can configure and play the simulator until the AI model maximizes the score as best it can or training is terminated by some other condition.

In the foregoing Inkling™ code block for the “no_bricks” lesson, the keyword “lesson” is also used to name the lesson (e.g., “no_bricks”) and the keyword “configure” is used to declare a configuration for training data for the lesson, which happens to use the same constraints as the “score_lesson.” The keyword “until” is also used in the “no_bricks” lesson to specify how extensive training for the neural network should be; however, the return value for objective function “ball_location_distance” for the “no_bricks” lesson is to be minimized per the keyword “minimize.”

In the foregoing Inkling™ code block for the “more_bricks” lesson, the keyword “lesson” names the lesson (e.g., “more_bricks”), and the optional keyword “follows” indicates a preceding lesson (e.g., “no_bricks”), which can be used to specify an order of lessons in a curriculum for training a concept. If not the keyword “follows” is not used to specify an order of lessons, lessons are executed in parallel, which slows training of the neural network. Again, the keyword “configure” declares a configuration for training data for the lesson, which, in this case, constrains the schema-defined “bricks_percent” to 0.8%, “level” to level 20, and “paddle width” to 1 in the Breakout simulator. Like the “no_bricks” lesson, the objective function “ball_location_distance” for the “more_bricks” lesson is to be minimized per the keyword “minimize.”

Lessons can determine an amount of time it takes for training a neural network. More complex lessons can build on other, simpler lessons to reduce the amount of time it takes for training a neural network. For example, if a neural network is to be trained on the “ball_location” concept with the “ball_location_curriculum,” the neural network can be firstly trained with the “no_bricks” lesson, which describes an easier version of Breakout with fewer bricks (e.g., constrain bricks_percent=0.5), a lower level (e.g., constrain level=1), and a wider paddle (e.g., constrain paddle_width=4). Once the AI model consistently returns minimized values for the objective function “ball_location_distance” for the easier environment of the “no_bricks” lesson, the neural network can be secondly trained with the “more_bricks” lesson, which describes a more difficult version of Breakout with more complexity including more bricks (e.g., constrain bricks_percent=0.8), a higher level (e.g., constrain level=20), and a narrower paddle (e.g., constrain paddle_width=1). In this way, the AI model can progress from an easier environment to more and more complex environments.

In view of the foregoing, the pedagogical programming language Inkling™ can be configured to enable an author to define each of the one or more lessons by name; a leading lesson to follow via keyword “follows”; data configuration for the lesson via keyword “configure”; and the termination condition for the curriculum-defined objective for the concept node to be trained.

Schemas

Schema references or schemas in Inkling™ describe data types or the structure of data such as input data for a mental model, data between one or more concept nodes of a mental model, data between one or more stream nodes of a mental model, and output data of a mental model. Because the architect module maps one or more nodes of a mental model onto one or more modes of a neural network, schemas also describe the structure of data such as input data into a neural network, data among nodes of a neural network, and output data of a neural network. As such, the pedagogical programming language Inkling™ is configured to enable an author to define schemas describing one or more data types to be streamed through a mental model including one or more concept nodes and one or more stream nodes.

Data types are the most basic building blocks for data manipulation. A data type provides information regarding the meaning of corresponding data, the possible values of the data, the operations that can be performed on the data, and the way the data can be stored. Supported data types in Inkling™ include, but are not limited to, primitive data types, which include data types selected from strings (e.g., String), integers (e.g., Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64), floats (e.g., Double, Float64, Float32), and Booleans (e.g., Bool); structured data types (e.g., structured data types for machine learning); constrained data types with range expressions limiting the data of the constrained data types including primitive data types constrained with a range expression; native data types such as data types for working with media formats (e.g., images, audio, video, etc.); and combinations thereof. For native data types, metadata from, for example, media formats such as images, audio, and video can be used to guide training of a neural network and improve learning of the neural network.

With reference to FIGS. 4C-4E, each connector of a number of connectors between connected nodes of a mental model can include a data type such as one of the foregoing data types (e.g., primitive data types, structured data types, constrained data types, and native data types), and the mental-model designer 412 of the IDE can be configured to color code the number of connectors in the mental model to indicate whether the data type between the connected nodes of the mental model is correct or not for each connector.

Schemas are expressed as records and can include a set of one or more fields, each of which fields can have a name and a data type that can be used for data manipulation. Schemas expressed as named records are named schemas, while schemas expressed as unnamed records are anonymous schemas. For example, a schema including a set of one or more field declarations in the record where the schema name would otherwise appear can be an anonymous schema. The following Inkling™ code blocks, for example, declares schemas used in the examples herein above, namely “GameState” “PlayerMove,” and “BreakoutConfig”:

schema GameState (   Luminance(84, 84) pixels # board state ) schema PlayerMove (   String{“left”, “no move”, “right”} move ) schema BreakoutConfig (   UInt32 level, # ‘level’, ‘paddle_width’, ‘bricks_percent’   UInt8 paddle_width, # are matched below in constrain clauses   Float32 bricks_percent )

With respect to the foregoing Inkling™ code blocks, the schema “GameState” is configured to represent input such as a grayscale image of a Breakout screen from the Breakout simulator. “Luminance” names a structured data type used in machine learning, which declares the input is a grayscale image of the Breakout screen where the values of the data are floats between 0 (black) and 1 (white). The schema “PlayerMove” is configured to represent output such as moves available for the Breakout paddle. “String” names a primitive data type, which declares the output is a move to the left, no move, or a move to the right. Likewise, the schema “BreakoutConfig” is configured to represent data regarding different configurations or aspects of Breakout play including level, paddle width, and percent of bricks on a screen. “UInt32” names a primitive data type for the level using an unsigned 32-bit integer; “UInt8” names a primitive data type for the paddle width using an unsigned 8-bit integer; and “Float32” names a primitive data type for the percent of bricks on the screen using a 32-bit float.

The Inkling™ compiler can be configured to check (e.g., static check) to verify that the schemas in an Inkling™ file are valid in the context in which they are used. However, the compiler does not enforce the schema—a streaming demon enforces the schema. Upon executing the compiler on an Inkling™ file, the compiler can match-check the schemas and report one or more errors if the schemas expected to match do not match. The match-check is structural, not name based. Field names do not matter. For example, the match-check is structural in that a pair of the schemas with different schema names can match if the pair of the schemas define the same list of field types in the same order. For structured data types with size, the sizes must be equal. In addition, two references by name to the same schema match because a schema matches itself. Two anonymous schemas match if both anonymous schemas define the same field types in the same order. And a schema referenced by name matches an anonymous schema if both define the same field types in the same order.

Blocks

A block in Inkling™ is a unit of reuse. A block is a collection of one or more schemas, one or more concept nodes, one or more stream nodes, or a combination thereof that can be used and reused by an Inkling™ author; however, blocks do not include any curriculums. Authors do not need to know the internals of a block. A block can include a single input and a single output using reserved names for the input and the output. A block can use an import statement to access concepts and streams outside the block.

A block encapsulates a portion of a mental model. Each block in an Inkling™ file can include one or more block-encapsulated concept nodes, one or more block-encapsulated stream nodes, and one or more block-encapsulated schemas without any curriculums for training the neural network. Each block in an Inkling™ file can be configured to accept input from any one or more of the one or more concept nodes or the one or more stream nodes of the mental model, as well as provide output to any other one of the one or more concept nodes or the one or more stream nodes of the mental model.

Other features of the AI systems and methods provided herein can be better understood with reference to the following:

Foundational Primitives

AI systems and methods provided herein enable a teaching-oriented approach by providing a set of foundational primitives that can be used to represent AI without specifying how the AI is created. These foundational primitives are 1) concepts and mental models, 2) curricula and lessons, and 3) training-data sources, as described in further detail herein. Concepts and mental models, as well as curricula and lessons, can be expressed in a pedagogical programming language.

AI Engine

The AI system 600 (see FIG. 6) enables developers to more efficiently build, teach, and use intelligence models.

The AI engine takes in a description of a problem and how one would go about teaching concepts covering aspects of the problem to be solved, and the AI engine compiles the coded description into lower-level structured data objects that a machine can more readily understand, builds a network topology of the main problem concept and sub-concepts covering aspects of the problem to be solved, trains codified instantiations of the sub-concepts and main concept, and executes a trained AI model containing one, two, or more neural networks.

The AI engine can abstract away and automate the low-level mechanics of AI, and the AI engine can manage and automate much of the lower level complexities of working with AI. Each program developed in a pedagogical programming language can be fed into the AI engine in order to generate and train appropriate intelligence models, which can be referred to as Basic Recurrent Artificial Intelligence Networks (“BRAINs”) herein. At its heart, a BRAIN can be a topology or a basic network of intelligent processing nodes that comprise a potentially recurrent network, hence the acronym “BRAIN.”

The AI engine can abstract generation of a neural network topology for an optimal solution and faster training time with a curriculum and lessons to teach the neural network via recursive simulations and training sessions on each node making up the neural network.

The AI engine can contain a vast array of machine learning algorithms for various AI models, has logic for picking learning algorithms and guiding training, manages data streaming and data storage, and provides the efficient allocation of hardware resources. The AI engine can be built with an infrastructure that supports streaming data efficiently through the system, and the AI engine can use a set of heuristics to make choices about which learning algorithms to use to train each BRAIN. The set of heuristics also make it possible for the AI engine to choose from any number of possible algorithms, topologies, etc., train a number of BRAINs in parallel, and pick the best result.

The AI engine can be a cloud-hosted platform-as-a-service configured to manage complexities inherent to training AI networks. Thus, the AI engine can be accessible with one or more client-side interfaces to allow third parties to submit a description of a problem in a pedagogical programming language and let the online AI engine build and generate a trained intelligence model for one or more of the third parties.

Major AI-System Components

FIG. 6 provides a schematic illustrating an AI system 600 including an AI engine in accordance with some embodiments.

The details for any given implementation of a BRAIN server may vary substantially, but many have common architectural components such as the following six components: 1) an architect module, 2) an instructor module, 3) a learner module, 4) a hyperlearner module, 5) a compiler, and 6) one or more interfaces exchanging communications into and out of the AI engine.

Following on the AI system 200 of FIGS. 2A and 3A, the AI system 600 includes the client interface 212 on the one or more client systems and the following on the one or more server systems: the compiler 222; the AI-generator modules including the instructor module 324, the architect module 326, and the learner module 328, the hyperlearner module 325, and the predictor module 329. In addition to the foregoing, the AI system 600 can include a training data loader 621 configured to load training data, a training data database 614 a, a simulator 614 b, and a streaming data server 623. The training data can be batched training data, streamed training data, or a combination thereof, and a training data manager can be configured to push or pull the training data from one or more training data sources selected from a simulator, a training-data generator, a training-data database, or a combination thereof. A batch data source can supply batched data from a database in at least one embodiment. A random-data generator can generate random data based on user-input parameters. Further in addition to the foregoing, FIG. 6 shows the architect module 326 configured to propose a neural network layout such as the neural network layout 102 and the learner module 328 configured to save a trained state of a neural network such as the trained neural network 106.

Architect Module

The architect module is the component of the system responsible for proposing and optimizing learning topologies (e.g., neural networks) based on mental models.

Neural networks can be based on a large collection of neural units loosely modeling the way a biological brain solves problems with large clusters of biological neurons connected by axons. Each neural unit is connected with many others, and links can be enforcing or inhibitory in their effect on the activation state of connected neural units. Each individual neural unit can have, for example, a summation function, which combines the values of all its inputs together. There may be a threshold function or limiting function on each connection and on the unit itself such that it must surpass it before it can propagate to other neurons. These systems are self-learning and trained rather than explicitly programmed and excel in areas where the solution or feature detection is difficult to express in a traditional computer program.

Neural networks can consist of multiple layers or a cube design, and the signal path can traverse from front to back. The goal of the neural network is to solve problems in the same way that the human brain would, although several neural networks are much more abstract. Modern neural network projects typically work with a few thousand and up to a few million neural units and millions of connections.

The architect module can take the codified mental model and pedagogy and propose a set of candidate low-level learning algorithms, topologies of a main concepts and sub-concepts, and configurations thereof the architect module believes will best be able to learn the concepts in the model. This is akin to the work that a data scientist does in the toolkit approach, or that the search system automates in the approach with statistical data analysis tools. Here, it is guided by the pedagogical program instead of being a broad search. The architect module can employ a variety of techniques to identify such models. The architect module can generate a directed graph of nodes or a low-level instantiation of a high-level mental model. The architect module can break down the problem to be solved into smaller tasks/concepts all factoring into the more complex main problem trying to be solved. The architect module can instantiate a main concept and layers of sub-concepts feeding into the main concept. The architect module can generate each concept including the sub-concepts with a tap that stores the output action/decision and the reason why that node reached that resultant output (e.g., what parameters dominated the decision and/or other factors that caused the node to reach that resultant output). This stored output of resultant output and the reasons why the node reached that resultant output can be stored in the trained intelligence model. The tap created in each instantiated node allows explainability for each step in an intelligence model on how a trained intelligence model produces its resultant output for a set of data input. The architect module can reference a database of algorithms to use as well as a database of network topologies to utilize. The architect module can reference a table or database of best suggested topology arrangements including how many layers of levels in a topology graph for a given problem, if available. The architect module also has logic to reference similar problems solved by comparing signatures. If the signatures are close enough, the architect module can try the topology used to optimally solve a problem stored in an archive database with a similar signature. The architect module can also instantiate multiple topology arrangements all to be tested and simulated in parallel to see which topology comes away with optimal results. The optimal results can be based on factors such as performance time, accuracy, computing resources needed to complete the training simulations, etc.

In some embodiments, for example, the architect module can be configured to propose a number of neural networks and heuristically pick an appropriate learning algorithm from a number of machine learning algorithms in one or more databases for each of the number of neural networks. The instructor module and the learner module can be configured to train the number of neural networks in parallel. The number of neural networks can be trained in one or more training cycles with the training data from one or more training data sources. The AI engine or a predictor module thereof can subsequently instantiate a number of trained neural networks based on the concepts learned by the number of neural networks in the one or more training cycles, and the AI engine can identify a best trained neural network (e.g., by means of optimal results based on factors such as performance time, accuracy, etc.) among the number of trained neural networks.

The user can assist in building the topology of the nodes by setting dependencies for particular nodes. The architect module can generate and instantiate neural network topologies for all of the concepts needed to solve the problem in a distinct two-step process. The architect module can generate a description of the network concepts. The architect module can also take the description and instantiate one or more topological shapes, layers, or other graphical arrangements to solve the problem description. The architect module can select topology algorithms to use based on factors such as whether the type of output the current problem has either 1) an estimation output or 2) a discrete output and then factors in other parameters such as performance time to complete the algorithm, accuracy, computing resources needed to complete the training simulations, originality, amount of attributes, etc.

Instructor Module

The instructor module is a component of the system responsible for carrying out a training plan codified in a pedagogical programming language. Training can include teaching a neural network to get one or more outcomes, for example, on a simulator. The training can involve using a specific set of concepts, a curriculum, and lessons, which can be described in a file in a pedagogical programming language. The instructor module can train easier-to-understand tasks earlier than more complex tasks. Thus, the instructor module can train sub-concept nodes and then higher-level nodes. The instructor module can train sub-concept nodes that are dependent on other nodes after those other nodes are trained. However, multiple nodes in a graph may be trained in parallel. The instructor module can run simulations on the nodes with input data including statistics and feedback on results from the node being trained from the learner module. The learner module and instructor module can work with a simulator or other data source to iteratively train a node with different data inputs. The instructor module can reference a knowledge base of how to train a node efficiently by different ways of flowing data to one or more nodes in the topology graph in parallel, or, if dependencies exist, the instructor module can train serially with some portions of lessons taking place only after earlier dependencies have been satisfied. The instructor module can reference the dependencies in the topology graph, which the dependencies can come from a user specifying the dependencies and/or how the arrangement of nodes in the topology was instantiated. The instructor module can supply data flows from the data source such as a simulator in parallel to multiple nodes at the same time where computing resources and a dependency check allows the parallel training.

Learner Module

The learner module is a component of the system configured to carry out the actual execution of the low-level, underlying AI algorithms. In training mode, the learner module can instantiate a system conforming to what was proposed by the architect module, interface with the instructor module to carry out the computation and assess performance, and then execute the learning algorithm itself. In execution mode, the learner module can instantiate and execute an instance of the already trained system. Eventually, the learner module writes out network states for each trained sub-node and then a combination of the topological graph of the main node with all of the sub-nodes into a trained intelligence model referred to herein as a BRAIN. The learner module can also write the stored output of each node and why that node arrived at that output into the BRAIN, which gives explainability as to how and why the AI proposes a solution or arrives at an outcome.

Hyperlearner Module

The hyperlearner module can perform a comparison of a current problem to a previous problem in one or more databases. The hyperlearner module can reference archived, previously built and trained intelligence models to help guide the instructor module to train the current model of nodes. The hyperlearner module can parse an archive database of trained intelligence models, known past similar problems and proposed solutions, and other sources. The hyperlearner module can compare previous solutions similar to the solutions needed in a current problem as well as compare previous problems similar to the current problem to suggest potential optimal neural network topologies and training lessons and training methodologies.

Transformer

The transformer can carry out streaming data transformations that do not require learning. When authors create BRAIN models, some concepts do not require learning and code specifying explicitly how to calculate them can be specified. For example, if an author wants to use the concept of a moving average, rather than have the system learn how to calculate the moving average, the author can explicitly specify how to calculate the moving average. Such transformations take the form of “stream” statements in a pedagogical programming language such as Inkling™. The transformer can carry out the actual execution of such transformations when needed.

Predictor Module

After an algorithm is trained, the trained neural network can be hosted in a “prediction mode.” The prediction mode can hold a neural network for use as an HTTP API endpoint. The programmer can then send input data to the predictor module and get back a prediction.

Compiler

The compiler module automates conversion and compiling of the pedagogical programming language describing the problem (main concept) and sub-concepts factoring into the problem. Each statement recited in the pedagogical programming language can be complied into a structured data object's defined fields, which can later be generated and instantiated into its own sub-concept node by the architect module. Each node can have one or more inputs one or more neural networks to process the input data and a resulting output decision/action. The compiled statements, commands, and other codifications fed into the AI compiler can be transformed into a lower level AI specification.

Simulator

If the curriculum trains using a simulation or procedural generation, the data for a lesson is not data to be passed to the learning system, but data is to be passed to the simulator. Otherwise, then the data can be optionally filtered/augmented in the lessons before being passed to the learning system. The simulator can use this data to configure itself, and the simulator can subsequently produce a piece of data for the learning system to use for training. This separation permits a proper separation of concerns. The simulator is the method of instruction, and the lesson provides a way to tune that method of instruction, which makes it more or less difficult depending on the current level of mastery exhibited by the learning system. A simulation can run on a client machine and stream data to the AI engine for training. In such an embodiment, the client machine needs to remain connected to the AI engine while the BRAIN is training. However, if the client machine is disconnected from the server of the AI engine, it can automatically pick up where it left off when it is reconnected.

Note, 1) simulations and procedural generation are a good choice versus data in a variety of circumstances; and 2) concepts are a good choice versus streams when you can more easily teach versus calculate.

Simulators can be reused to teach multiple concepts.

Modes of Operation

A BRAIN server has at least three modes of operation: authoring/debugging, training, and execution (or prediction). In practice, all three can run concurrently, and most implementations of a BRAIN server are high-availability, multi-tenant, distributed systems. That being said, each individual user generally works in one mode of operation at a time.

Authoring/Debugging Mode

When in authoring/debugging mode of operation, a BRAIN server can be tuned to assisting a user in iteratively developing a mental model and pedagogy. For example, in the authoring/debugging mode a user can set breakpoints on nodes in a BRAIN model, and when a breakpoint is hit the user can inspect the chain of stream processing leading up to that node. Even though a given node can represent a neural network or other complex AI learning system, because of the way training is conducted, the system can encode and decode from high-dimensional tensor representations into the output types associated with a concept. This does not mean that high-dimensional representations are necessarily collapsed between nodes, just that decoders are learned for all nodes. In addition to this direct model-inspection capability, an author can similarly debug curricula. For example, one can set a watch condition on a particular lesson and compare the actual training performance and adapted learning execution plan versus the canonical, codified lesson ordering. Advanced users can inspect the underlying learning algorithms themselves, and debugging tooling can assist in visualizing what was actually learned in concepts that are not understood as intended.

Since many developers might be concurrently working on a given BRAIN model, the authoring mode also handles keeping representations that are under development, in training, and deployed separate.

Training Mode

When in training mode of operation, the instructor module and the learner module are configured to i) instantiate the neural network conforming to the neural network proposed by the architect module and ii) train the neural network. To effect the foregoing, the BRAIN server can take compiled code and generate a BRAIN learning topology, and proceed to follow the curricula to teach the concepts as specified. Depending on the model, training can potentially take substantial amounts of time. Consequently, the BRAIN server can provide interactive context on the status of training. For example, the BRAIN server can show which nodes are actively being trained, the current belief about each node's mastery of its associated concept, overall and fine-grained accuracy and performance, the current training execution plan, and an estimate of completion time. As such, in some embodiments, the AI engine can be configured to provide one or more training status updates on training a neural network selected from i) an estimation of a proportion of a training plan completed for the neural network, ii) an estimation of a completion time for completing the training plan, iii) the one or more concepts upon which the neural network is actively training, iv) mastery of the neural network on learning the one or more concepts, v) fine-grained accuracy and performance of the neural network on learning the one or more concepts, and vi) overall accuracy and performance of the neural network on learning one or more mental models.

Because the process of building pedagogical programs is iterative, the BRAIN server in training mode can also provide incremental training. That is to say, if the code is altered with respect to a concept that comes after other concepts that have already been trained, those antecedent concepts do not need to be retrained.

Additionally, in training mode, the user is able to specify what constitutes satisfactory training should the program itself permit indefinite training.

When starting a training operation, the instructor module can first generate an execution plan. This is the ordering the instructor module intends to use when teaching the concepts, and, for each concept, the lessons the instructor module intends to teach in what order. While the execution plan is executing, the instructor module can jump back and forth between concepts and lessons to optimize the learning rate. By not being required to train each concept fully before starting to train dependent concepts, the system can naturally avoid certain systemic machine-learning problems such as overfitting. The major techniques used to determine when to switch between lessons and concepts for training are reinforcement learning and adaptive learning. For example, for a first main problem of determining an amount of bankruptcy filings in the United States, a first sub-node can be trained in a first lesson on how to determine bankruptcy filings in California. A second lesson can train the first sub-node on how to determine bankruptcy filings in California and York. Successive lessons on a node can build upon and augment earlier lessons that the node was trained on in a training session.

Execution Mode

When in execution mode or prediction mode of operation, a predictor AI module can be configured to i) instantiate and execute the trained neural network on the training data for one or more predictions in the predicting mode. To effect the foregoing, a BRAIN server can take a trained BRAIN model, enable API endpoints so that data can be streamed to and from the model, and then optimize its distribution for performance. Because learned and specified data transformations can be functional in nature, the transformations can be automatically parallelized and distributed to hardware that can accelerate their execution. Text processing, for example, can be distributed to a cluster of machines with substantial CPU resources, while nodes leveraging deep learning might be similarly distributed to a cluster of machines with substantial GPU resources.

Operational management of the executing BRAIN model can also be undertaken in this mode. This includes monitoring data ingestion rates, execution performance (both in terms of speed and accuracy), logs, event subscriptions, or the like through an operational dashboard.

Other features of the AI systems and methods provided herein for authoring/debugging, training, and execution (or prediction) can be better understood with reference to the following:

Algorithm Selection

A first step a BRAIN server can take is to pick an appropriate learning algorithm to train a mental model. This is a notable step in training AI, and it is a step those without AI expertise cannot perform without expert guidance. The BRAIN server can have knowledge of many of the available learning algorithms, as well as a set of heuristics for picking an appropriate algorithm including an initial configuration to train from.

For example, if the BRAIN server picks Deep Q-Learning for training a mental model, it would also pick an appropriate topology, hyper-parameters, and initial weight values for synapses. A benefit of having the heuristics available to be used programmatically is that the BRAIN server is not limited to a single choice; it can select any number of possible algorithms, topologies, etc., train a number of BRAINS in parallel, and pick the best result.

The process of picking an appropriate algorithm, etc., is performed by a BRAIN that has been trained (and will continue to be trained) by the AI engine, meaning the BRAIN will get better at building BRAINs each time a new one is built. A trained AI-engine neural network such as a BRAIN thereby provides enabling AI for proposing neural networks from assembly code and picking appropriate learning algorithms from a number of machine learning algorithms in one or more databases for training the neural networks. The AI engine can be configured to continuously train the trained AI-engine neural network in providing the enabling AI for proposing the neural networks and picking the appropriate learning algorithms thereby getting better at building BRAINs.

The architect module can also use heuristics, mental model signatures, statistical distribution inference, and meta-learning in topology and algorithm selection:

First, the architect module can be configured to heuristically pick an appropriate learning algorithm from a number of machine learning algorithms in one or more databases for training the neural network proposed by the architect module. Many heuristics regarding the mental model can be used to inform what types of AI and machine learning algorithms can be used. For example, the data types used have a large influence. For this reason, the pedagogical programming language can contain rich native data types in addition to the basic data types. If the architect module sees, for example, that an image is being used, a convolutional deep learning neural network architecture might be appropriate. If the architect module sees data that is temporal in nature (e.g., audio data, sequence data, etc.), then a recursive deep-learning neural network architecture like a long short-term memory (“LSTM”) network might be more appropriate. The collection of heuristics can be generated by data science and machine learning/AI experts who work on the architect module codebase, and who attempt to capture the heuristics that they themselves use in practice.

The system can also calculate a signature for a mental model. These signatures are a form of hashing such that mental models that have similar machine learning algorithmic characteristics have similar signatures. These signatures can then be used in conjunction with heuristics and with meta-learning.

In addition to looking at the mental model, the architect module can also consider the pedagogy provided in the code. It can, for example, look at the statistical distribution of any data sets being used; and, in the case of simulators, it can ask the simulator to generate substantial amounts of data so as to determine the statistics of data that will be used during training. These distribution properties can further inform the heuristics used.

Meta-learning is an advanced technique used by the architect module. It is, as the name implies, learning about learning. What this means is that as the architect module can generate candidate algorithm choices and topologies for training, it can record this data along with the signature for the model and the resultant system performance. This data set can then be used in its own learning system. Thus the architect module, by virtue of proposing, exploring, and optimizing learning models, can observe what works and what doesn't, and use that to learn what models it should try in the future when it sees similar signatures.

To effect meta-learning, the AI engine can include a meta-learning module configured to keep a record such as a meta-learning record in one or more databases. The record can include i) the source code processed by the AI engine, ii) mental models of the source code and/or signatures thereof, iii) the training data used for training the neural networks, iv) the trained neural networks, v) how quickly the trained neural networks were trained to a sufficient level of accuracy, and vi) how accurate the trained neural networks became in making predictions on the training data.

For advanced users, low-level details of a learning topology can be explicitly specified completely or in part. The architect module can treat any such pinning of parameters as an override on its default behavior. In this way, specific algorithms can be provided, or a generated model can be pinned for manual refinement.

Guiding Training

Once an algorithm is chosen, the BRAIN server can proceed with training the BRAIN's mental model via curricula and the lessons thereof. The BRAIN server can manage the data streaming, data storage, efficient allocation of hardware resources, choosing when to train each concept, how much (or little) to train a concept given its relevance within the mental model (e.g., dealing with problems of overfitting and underfitting), and is generally responsible for producing a trained BRAIN based on the given mental model and curricula. The AI engine is thus configured to make determinations regarding i) when to train the neural network on each of the one or more concepts and ii) how extensively to train the neural network on each of the one or more concepts. Such determinations can be based on the relevance of each of one or more concepts in one or more predictions of a trained neural network based upon training data.

As is the case with picking an appropriate learning algorithm, guiding training—notably avoiding overfitting and underfitting—to produce an accurate AI solution is a task that requires knowledge and experience in training AIs, and the BRAIN server can have an encoded set of heuristics to manage this with little or no user involvement. Similarly, the process of guiding training is also a BRAIN that has been trained that will only get smarter with each BRAIN it trains.

The AI engine can also determine when to train each concept, how much (or little) to train each concept based on its relevance, and, ultimately, produce a trained BRAIN. Furthermore, the AI engine can utilize meta-learning. In meta-learning, the AI engine keeps a record of each program it's seen, the data it used for training, and the generated AIs that it made. It also records how fast those AIs trained and how accurate they became. The AI engine server learns over that dataset.

Stream Oriented, Data-Flow Processing

A BRAIN server can, under the hood, operate on streams of data, and can thus be considered a data flow-processing system. Data can be streamed into the BRAIN server through a traditional program, the data can flow through the nodes in the BRAIN model (including recurrent flows), and processed output can be made available in either an immediate or asynchronous, event-based model to the caller. All data that flows through the system can be ephemeral, unless a user explicitly creates a persisted data store in their program. At its heart, a BRAIN can be a basic network of intelligent processing nodes that comprise a potentially recurrent network, hence the acronym “BRAIN.”

Learning Backends

Learning backends encode underlying detail needed to work with a particular AI or machine learning algorithm. The BRAIN server can provide many backends such as backends for deep learning. However, learning-algorithm authors can provide their own backends if desired. By architecting the BRAIN server in this way, code in a pedagogical programming language can include another level of abstraction from a particular approach. If a new learning algorithm is created that has superior performance to existing algorithms, all that need be added is a new backend. The architect module can then immediately start using the backend to build systems, and existing programs written in a pedagogical programming language can be recompiled without modification to take advantage of the improved algorithms.

Learning backends use the schemas set forth in a pedagogical programming language to translate big matrices to usable values.

Online Learning

In addition to capabilities for migrating learned state, some implementations of the BRAIN server afford features to enable online learning. Since online learning can break the pure functional nature of nodes via state changes during runtime, another strategy that the system is configured to afford is persisting training data learned online using a data daemon, incrementally training the network at set intervals, and then redistributing the updated network as a functional block throughout the BRAIN server.

Migrations of Learned State

When a system has undergone substantial training achieving a learned state, and a subsequent change to the underlying mental models might necessitate retraining, it could be desirable to migrate the learned state rather than starting training from scratch. The BRAIN server can be configured to afford transitioning capabilities such that previously learned high dimensional representations can be migrated to appropriate, new, high dimensional representations. This can be achieved in a neural network by, for example, expanding the width of an input layer to account for alterations with zero-weight connections to downstream layers. The system can then artificially diminish the weights on connections from the input that are to be pruned until they hit zero and can then be fully pruned.

Deploy and Use

Once a BRAIN has been sufficiently trained, it can be deployed such that it can be used in a production application. The interface for using a deployed BRAIN is simple: the user submits data (of the same type as the BRAIN was trained with) to a BRAIN-server API and receives the BRAIN's evaluation of that data.

As a practical example of how to use a deployed BRAIN, a BRAIN can first be trained to recognize hand-written digits from the Mixed National Institute of Standards and Technology (“MNIST”) dataset. An image can be created containing a handwritten digit, perhaps directly through a touch-based interface or indirectly by scanning a piece of paper with the handwritten digit written on it. The image can then be downsampled to a resolution of 28×28 and converted to grayscale, as this is the input schema used to train the example BRAIN. When submitted to the BRAIN-server through the BRAIN server API, the BRAIN can take the image as input and output a one-dimensional array of length 10 (whereby each array item represents the probability, as judged by the BRAIN, that the image is a digit corresponding to the index). The array could be the value returned to the user from the API, which the user could use as needed.

Though a linear approach to building a BRAIN is presented in some embodiments, an author-train-deploy workflow does not have to treated as a waterfall process. If the user decides further refinement of a BRAIN is needed, be it through additional training with existing data, additional training with new, supplemental data, or additional training with a modified version of the mental model or curricula used for training, the BRAIN-server is configured to support versioning of BRAINs so that the user can preserve (and possibly revert to) the current state of a BRAIN while refining the trained state of the BRAIN until a new, more satisfactory state is reached.

FIG. 7A provides a schematic illustrating an AI system 700A in accordance with some embodiments.

As shown in FIG. 7A, a user such as a software developer can interface with the AI system 700A through an online interface; however, the user is not limited to the online interface, and the online interface is not limited to that shown in FIG. 7A. With this in mind, the AI system 700A of FIG. 7A can enable a user to make API and web requests through a domain name system (“DNS”), which requests can be optionally filtered through a proxy to route the API requests to an API load balancer and the web requests to a web load balancer. The API load balancer can be configured to distribute the API requests among multiple BRAIN service containers running in a Docker network or containerization platform configured to wrap one or more pieces of software in a complete filesystem containing everything for execution including code, runtime, system tools, system libraries, etc. The web load balancer can be configured to distribute the web requests among multiple web service containers running in the Docker network. The Docker network or Docker BRAIN network can include central processing unit (“CPU”) nodes and graphics processing unit (“GPU”) nodes, the nodes of which Docker network can be autoscaled as needed. The CPU nodes can be utilized for most BRAIN-service containers running on the Docker network, and the GPU nodes can be utilized for the more computationally intensive components such as TensorFlow and the learner module. As further shown in FIG. 7A, a BRAIN-service engineer can interface with the AI system 700A through virtual private cloud (“VPC”) gateway and a hardened bastion host configured to secure the Docker network. An Elastisearch-Logstash-Kibana (“ELK”) stack cluster can be shared among all production clusters for dedicated monitoring and logging.

FIG. 7B provides a schematic illustrating an AI system 700B in accordance with some embodiments.

Following on the AI system 700A, the bastion host and one or more CPU nodes can be on a public subnet for bidirectional communication through an Internet gateway. One or more other CPU nodes, as well as the GPU nodes, can be on a private subnet communicatively coupled with the public subnet by means of a subnet therebetween. The one or more CPU nodes on the public subnet can be utilized by the compiler 222 of FIGS. 2A, 3A, and 5, and the architect module 326 of FIGS. 3A and 5. The one or more other CPU nodes on the private subnet can be utilized by the instructor module 324 of FIGS. 3A and 5, and the GPU nodes can be utilized by the learner module 328 and the predictor module 329 of FIGS. 3A and 5. As further shown in FIG. 7B, the private subnet can be configured to send outgoing communications to the Internet through a network address translation (“NAT”) gateway.

Methods

A method of an AI system includes, in some embodiments, the AI system configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI. The method can include receiving a source code, generating an assembly code from the source code, proposing a neural-network layout from the assembly code, building an AI model from the neural-network layout, and training the AI model. Receiving the source code can include receiving the source code through an API exposed to the multiple user interfaces. Generating the assembly code can include generating the assembly code from the source code with a compiler of an AI engine configured to work with the multiple interfaces. Proposing the neural-network layout can include proposing the neural-network layout including one or more neural-network layers from the assembly code with an architect AI-engine module of the AI engine. Building the AI model can include building the AI model including the one or more neural-network layers from the neural-network layout with a learner AI-engine module of the AI engine. Training the AI model can include training the AI model on the mental model with an instructor AI-engine module of the AI engine. The method can further include enabling an author to define a mental model and send the source code with the mental model through the API exposed to the multiple user interfaces. Enabling the author to define the mental model can include enabling the author to define the mental model for the AI model to learn and one or more curriculums written in a pedagogical programming language, the mental model including an input, one or more concept nodes, one or more optional stream nodes, and an output.

In such embodiments, each user interface of the multiple user interfaces can be selected from an integrated development environment (“IDE”), a web-browser interface, and a command-line interface (“CLI”). The different types of users solving the different types of problems with AI can be users having different levels of programming skills solving different problems with AI at least commensurate with the different levels of programming skills. The IDE, the web-browser interface, and the CLI can be designed to accommodate the users having the different levels of programming skills.

In such embodiments, the multiple user interfaces can include the CLI, and the method can further include enabling the author to send the source code to the compiler through the API exposed to the CLI, configure aspects of training the AI model, and connect the AI model to a simulator for the training.

In such embodiments, the multiple user interfaces include the web-browser interface, and the method can further include enabling the author to send the source code to the compiler through the API exposed to the web-browser interface, provide a name and description for a trained AI model prior to training the AI model, and indicate a data storage for testing data the trained AI model can execute subsequent to training the AI model.

In such embodiments, the multiple user interfaces can include the IDE, which IDE, in turn, can include a text editor and a mental-model designer. A first author-based modification of the mental model in the text editor can be automatically replicated in the mental model of the mental-model designer. A second author-based modification of the mental model in the mental model designer can be automatically replicated in the mental-model in the text editor. As such, the method can further include enabling the author to define the mental model by typing in a textual mode in the text editor, gesturing in a graphical mode in the mental-model designer, or a combination thereof.

In such embodiments, the method can further include enabling the author in the text editor to set one or more breakpoints in the source code written in the pedagogical programming language in the text editor. Setting the one or more breakpoints can automatically invoke highlighting in the mental-model designer for the one or more concept nodes of the mental model corresponding to the one or more breakpoints if the one or more breakpoints are set at the one or more concept nodes.

In such embodiments, each connector of a number of connectors between connected nodes of the mental model including the one or more concept nodes can include a data type selected from primitive data types including from strings, integers, floats, and Booleans; structured data types; constrained data types including range expressions limiting the data of the constrained data types; and combinations thereof. In such embodiments, the method can further include color coding the number of connectors of the mental model in the mental-model designer to indicate whether the data type between the connected nodes of the mental model is correct or not for each connector.

In such embodiments, the method can further include mapping with the architect module the one or more concept nodes of the mental model on the one or more neural-network layers of the AI model. In addition, the method can further include finding with the instructor module a starting point among the one or more concept nodes and the one or more curriculums for training the AI model.

In such embodiments, the method can further include training the AI model with the instructor module in one or more training cycles with training data from one or more training-data sources selected from a simulator, a training-data generator, a training-data database, or a combination thereof based on training parameters in the pedagogical programming language. In addition, the method can further include terminating the training of the AI model upon an instructor module-determined terminating condition.

Network

FIG. 8 illustrates a number of electronic systems and devices communicating with each other in a network environment in accordance with some embodiments. The network environment 800 has a communications network 820. The network 820 can include one or more networks selected from an optical network, a cellular network, the Internet, a Local Area Network (“LAN”), a Wide Area Network (“WAN”), a satellite network, a fiber network, a cable network, and combinations thereof. In some embodiments, the communications network 820 is the Internet. As shown, there may be many server computing systems and many client computing systems connected to each other via the communications network 820. However, it should be appreciated that, for example, a single client computing system can also be connected to a single server computing system. As such, FIG. 8 illustrates any combination of server computing systems and client computing systems connected to each other via the communications network 820.

The communications network 820 can connect one or more server computing systems selected from at least a first server computing system 804A and a second server computing system 804B to each other and to at least one or more client computing systems as well. The server computing systems 804A and 804B can be, for example, the one or more server systems 220 of FIGS. 2A and 3A. The server computing systems 804A and 804B can respectively optionally include organized data structures such as databases 806A and 806B. Each of the one or more server computing systems can have one or more virtual server computing systems, and multiple virtual server computing systems can be implemented by design. Each of the one or more server computing systems can have one or more firewalls to protect data integrity.

The at least one or more client computing systems can be selected from a first mobile computing device 802A (e.g., smartphone with an Android-based operating system), a second mobile computing device 802E (e.g., smartphone with an iOS-based operating system), a first wearable electronic device 802C (e.g., a smartwatch), a first portable computer 802B (e.g., laptop computer), a third mobile computing device or second portable computer 802F (e.g., tablet with an Android- or iOS-based operating system), a smart device or system incorporated into a first smart automobile 802D, a smart device or system incorporated into a first smart bicycle 802G, a first smart television 802H, a first virtual reality or augmented reality headset 804C, and the like. The client computing system 802B can be, for example, one of the one or more client systems 210 of FIGS. 2A and 3A, and any one or more of the other client computing systems (e.g., 802A, 802C, 802D, 802E, 802F, 802G, 802H, and/or 804C) can include, for example, the software application or the hardware-based system in which the trained neural network 106 can be deployed. Each of the one or more client computing systems can have one or more firewalls to protect data integrity.

It should be appreciated that the use of the terms “client computing system” and “server computing system” is intended to indicate the system that generally initiates a communication and the system that generally responds to the communication. For example, a client computing system can generally initiate a communication and a server computing system generally responds to the communication. No hierarchy is implied unless explicitly stated. Both functions can be in a single communicating system or device, in which case, the client-server and server-client relationship can be viewed as peer-to-peer. Thus, if the first portable computer 802B (e.g., the client computing system) and the server computing system 804A can both initiate and respond to communications, their communications can be viewed as peer-to-peer. Additionally, the server computing systems 804A and 804B include circuitry and software enabling communication with each other across the network 820.

Any one or more of the server computing systems can be a cloud provider. A cloud provider can install and operate application software in a cloud (e.g., the network 820 such as the Internet) and cloud users can access the application software from one or more of the client computing systems. Generally, cloud users that have a cloud-based site in the cloud cannot solely manage a cloud infrastructure or platform where the application software runs. Thus, the server computing systems and organized data structures thereof can be shared resources, where each cloud user is given a certain amount of dedicated use of the shared resources. Each cloud user's cloud-based site can be given a virtual amount of dedicated space and bandwidth in the cloud. Cloud applications can be different from other applications in their scalability, which can be achieved by cloning tasks onto multiple virtual machines at run-time to meet changing work demand. Load balancers distribute the work over the set of virtual machines. This process is transparent to the cloud user, who sees only a single access point.

Cloud-based remote access can be coded to utilize a protocol, such as Hypertext Transfer Protocol (“HTTP”), to engage in a request and response cycle with an application on a client computing system such as a web-browser application resident on the client computing system. The cloud-based remote access can be accessed by a smartphone, a desktop computer, a tablet, or any other client computing systems, anytime and/or anywhere. The cloud-based remote access is coded to engage in 1) the request and response cycle from all web browser based applications, 3) the request and response cycle from a dedicated on-line server, 4) the request and response cycle directly between a native application resident on a client device and the cloud-based remote access to another client computing system, and 5) combinations of these.

In an embodiment, the server computing system 804A can include a server engine, a web page management component, a content management component, and a database management component. The server engine can perform basic processing and operating-system level tasks. The web page management component can handle creation and display or routing of web pages or screens associated with receiving and providing digital content and digital advertisements. Users (e.g., cloud users) can access one or more of the server computing systems by means of a Uniform Resource Locator (“URL”) associated therewith. The content management component can handle most of the functions in the embodiments described herein. The database management component can include storage and retrieval tasks with respect to the database, queries to the database, and storage of data.

In some embodiments, a server computing system can be configured to display information in a window, a web page, or the like. An application including any program modules, applications, services, processes, and other similar software executable when executed on, for example, the server computing system 804A, can cause the server computing system 804A to display windows and user interface screens in a portion of a display screen space. With respect to a web page, for example, a user via a browser on the client computing system 802B can interact with the web page, and then supply input to the query/fields and/or service presented by the user interface screens. The web page can be served by a web server, for example, the server computing system 804A, on any Hypertext Markup Language (“HTML”) or Wireless Access Protocol (“WAP”) enabled client computing system (e.g., the client computing system 802B) or any equivalent thereof. The client computing system 802B can host a browser and/or a specific application to interact with the server computing system 804A. Each application has a code scripted to perform the functions that the software component is coded to carry out such as presenting fields to take details of desired information. Algorithms, routines, and engines within, for example, the server computing system 804A can take the information from the presenting fields and put that information into an appropriate storage medium such as a database (e.g., database 806A). A comparison wizard can be scripted to refer to a database and make use of such data. The applications may be hosted on, for example, the server computing system 804A and served to the specific application or browser of, for example, the client computing system 802B. The applications then serve windows or pages that allow entry of details.

Computing Systems

FIG. 9 illustrates a computing system 900 that can be, wholly or partially, part of one or more of the server or client computing devices in accordance with some embodiments. With reference to FIG. 9, components of the computing system 900 can include, but are not limited to, a processing unit 920 having one or more processing cores, a system memory 930, and a system bus 921 that couples various system components including the system memory 930 to the processing unit 920. The system bus 921 may be any of several types of bus structures selected from a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures.

Computing system 900 typically includes a variety of computing machine-readable media. Computing machine-readable media can be any available media that can be accessed by computing system 900 and includes both volatile and nonvolatile media, and removable and non-removable media. By way of example, and not limitation, computing machine-readable media use includes storage of information, such as computer-readable instructions, data structures, other executable software or other data. Computer-storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other tangible medium which can be used to store the desired information and which can be accessed by the computing device 900. Transitory media such as wireless channels are not included in the machine-readable media. Communication media typically embody computer readable instructions, data structures, other executable software, or other transport mechanism and includes any information delivery media. As an example, some client computing systems on the network 820 of FIG. 8 might not have optical or magnetic storage.

The system memory 930 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 931 and random access memory (RAM) 932. A basic input/output system 933 (BIOS) containing the basic routines that help to transfer information between elements within the computing system 900, such as during start-up, is typically stored in ROM 931. RAM 932 typically contains data and/or software that are immediately accessible to and/or presently being operated on by the processing unit 920. By way of example, and not limitation, FIG. 9 illustrates that RAM 932 can include a portion of the operating system 934, application programs 935, other executable software 936, and program data 937.

The computing system 900 can also include other removable/non-removable volatile/nonvolatile computer storage media. By way of example only, FIG. 9 illustrates a solid-state memory 941. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the example operating environment include, but are not limited to, USB drives and devices, flash memory cards, solid state RAM, solid state ROM, and the like. The solid-state memory 941 is typically connected to the system bus 921 through a non-removable memory interface such as interface 940, and USB drive 951 is typically connected to the system bus 921 by a removable memory interface, such as interface 950.

The drives and their associated computer storage media discussed above and illustrated in FIG. 9, provide storage of computer readable instructions, data structures, other executable software and other data for the computing system 900. In FIG. 9, for example, the solid state memory 941 is illustrated for storing operating system 944, application programs 945, other executable software 946, and program data 947. Note that these components can either be the same as or different from operating system 934, application programs 935, other executable software 936, and program data 937. Operating system 944, application programs 945, other executable software 946, and program data 947 are given different numbers here to illustrate that, at a minimum, they are different copies.

A user may enter commands and information into the computing system 900 through input devices such as a keyboard, touchscreen, or software or hardware input buttons 962, a microphone 963, a pointing device and/or scrolling input component, such as a mouse, trackball or touch pad. The microphone 963 can cooperate with speech recognition software. These and other input devices are often connected to the processing unit 920 through a user input interface 960 that is coupled to the system bus 921, but can be connected by other interface and bus structures, such as a parallel port, game port, or a universal serial bus (USB). A display monitor 991 or other type of display screen device is also connected to the system bus 921 via an interface, such as a display interface 990. In addition to the monitor 991, computing devices may also include other peripheral output devices such as speakers 997, a vibrator 999, and other output devices, which may be connected through an output peripheral interface 995.

The computing system 900 can operate in a networked environment using logical connections to one or more remote computers/client devices, such as a remote computing system 980. The remote computing system 980 can a personal computer, a hand-held device, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computing system 900. The logical connections depicted in FIG. 9 can include a personal area network (“PAN”) 972 (e.g., Bluetooth®), a local area network (“LAN”) 971 (e.g., Wi-Fi), and a wide area network (“WAN”) 973 (e.g., cellular network), but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet. A browser application may be resident on the computing device and stored in the memory.

When used in a LAN networking environment, the computing system 900 is connected to the LAN 971 through a network interface or adapter 970, which can be, for example, a Bluetooth® or Wi-Fi adapter. When used in a WAN networking environment (e.g., Internet), the computing system 900 typically includes some means for establishing communications over the WAN 973. With respect to mobile telecommunication technologies, for example, a radio interface, which can be internal or external, can be connected to the system bus 921 via the network interface 970, or other appropriate mechanism. In a networked environment, other software depicted relative to the computing system 900, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation, FIG. 9 illustrates remote application programs 985 as residing on remote computing device 980. It will be appreciated that the network connections shown are examples and other means of establishing a communications link between the computing devices may be used.

As discussed, the computing system 900 can include a processor 920, a memory (e.g., ROM 931, RAM 932, etc.), a built in battery to power the computing device, an AC power input to charge the battery, a display screen, a built-in Wi-Fi circuitry to wirelessly communicate with a remote computing device connected to network.

It should be noted that the present design can be carried out on a computing system such as that described with respect to FIG. 9. However, the present design can be carried out on a server, a computing device devoted to message handling, or on a distributed system in which different portions of the present design are carried out on different parts of the distributed computing system.

Another device that may be coupled to bus 921 is a power supply such as a DC power supply (e.g., battery) or an AC adapter circuit. As discussed above, the DC power supply may be a battery, a fuel cell, or similar DC power source that needs to be recharged on a periodic basis. A wireless communication module can employ a Wireless Application Protocol to establish a wireless communication channel. The wireless communication module can implement a wireless networking standard.

In some embodiments, software used to facilitate algorithms discussed herein can be embodied onto a non-transitory machine-readable medium. A machine-readable medium includes any mechanism that stores information in a form readable by a machine (e.g., a computer). For example, a non-transitory machine-readable medium can include read only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; flash memory devices; Digital Versatile Disc (DVD's), EPROMs, EEPROMs, FLASH memory, magnetic or optical cards, or any type of media suitable for storing electronic instructions.

Note, an application described herein includes but is not limited to software applications, mobile apps, and programs that are part of an operating system application. Some portions of this description are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like. These algorithms can be written in a number of different software programming languages such as C, C+, or other similar languages. Also, an algorithm can be implemented with lines of code in software, configured logic gates in software, or a combination of both. In an embodiment, the logic consists of electronic circuits that follow the rules of Boolean Logic, software that contain patterns of instructions, or any combination of both.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the above discussions, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers, or other such information storage, transmission or display devices.

Many functions performed by electronic hardware components can be duplicated by software emulation. Thus, a software program written to accomplish those same functions can emulate the functionality of the hardware components in input-output circuitry.

While the foregoing design and embodiments thereof have been provided in considerable detail, it is not the intention of the applicant(s) for the design and embodiments provided herein to be limiting. Additional adaptations and/or modifications are possible, and, in broader aspects, these adaptations and/or modifications are also encompassed. Accordingly, departures may be made from the foregoing design and embodiments without departing from the scope afforded by the following claims, which scope is only limited by the claims when appropriately construed. 

What is claimed is:
 1. An artificial intelligence (“AI”) engine configured to operate with multiple user interfaces to accommodate different types of users solving different types of problems with AI, comprising: an application programming interface (“API”) exposed to the multiple user interfaces configured to receive a source code written in a pedagogical programming language for compiling into an assembly code, wherein the multiple user interfaces enable an author to define a mental model for an AI model to learn and one or more curriculums written in the pedagogical programming language, the mental model including an input, one or more concept nodes, and an output, and wherein the multiple user interfaces further enable the author to send the source code through the API exposed to the multiple user interfaces to the compiler; and one or more AI-engine modules in the memory including an architect module, an instructor module, and a learner module, wherein the architect module, upon execution of the architect module by the one or more processors, is configured to propose a neural-network layout with one or more neural-network layers from the assembly code, wherein the learner module, upon execution of the learner module by the one or more processors, is configured to build the AI model with the one or more neural-network layers from the neural-network layout proposed by the architect module, wherein the instructor module, upon execution of the instructor module by the one or more processors, is configured to train the AI model built by the learner module on the one or more concept nodes, and wherein the multiple user interfaces improve the AI engine by improving a utilization rate and overall diversified utilization of the AI engine itself via having multiple user interfaces, each tailored to achieve a different purpose.
 2. The AI engine of claim 1, further comprising a compiler in a memory, wherein the compiler, upon execution of the compiler by one or more processors, is configured to generate the assembly code from the source code written in the pedagogical programming language, wherein the compiler is further configured to receive the source code through the API exposed to the multiple user interfaces, wherein each user interface of the multiple user interfaces is selected from an integrated development environment (“IDE”), a web-browser interface, and a command-line interface (“CLI”), wherein the different types of users solving the different types of problems with AI are users having different levels of programming skills solving different problems with AI at least commensurate with the different levels of programming skills, and wherein the IDE, the web-browser interface, and the CLI are designed to accommodate the users having the different levels of programming skills.
 3. The AI engine of claim 2, wherein the multiple user interfaces include the CLI, and wherein the CLI is configured to enable the author to send the source code to the compiler through the API exposed to the CLI, configure aspects of training the AI model, and connect the AI model to a simulator for the training.
 4. The AI engine of claim 2, wherein the multiple user interfaces include the web-browser interface, and wherein the web-browser interface is configured to enable the author to send the source code to the compiler through the API exposed to the web-browser interface, provide a name and description for a trained AI model prior to training the AI model, and indicate a data storage for testing data the trained AI model can execute subsequent to training the AI model.
 5. The AI engine of claim 2, wherein the multiple user interfaces include the IDE, the IDE including a text editor configured to enable the author to define the mental model by typing in a textual mode, and a mental-model designer configured to enable the author to define the mental model by mouse gestures in a graphical mode, wherein a first author-based modification of the mental model by the typing in the textual mode automatically replicates the first author-based modification of the mental model in the mental-model designer, and wherein a second author-based modification of the mental model by the mouse gestures in the graphical mode automatically replicates the second author-based modification of the mental-model in the text editor.
 6. The AI engine of claim 5, wherein the text editor is further configured to enable the author to set one or more breakpoints in the source code written in the pedagogical programming language, and wherein the mental-model designer is further configured to automatically highlight the one or more concept nodes of the mental model corresponding to the one or more breakpoints if the one or more breakpoints are set at the one or more concept nodes.
 7. The AI engine of claim 5, wherein the pedagogical programming language is configured to enable an author to define schemas describing one or more data types to be streamed through connected nodes of the mental model including the input, the one or more concept nodes, one or more stream nodes, and the output, and wherein the data types include primitive data types selected from strings, integers, floats, and Booleans; structured data types; constrained data types with range expressions limiting the data of the constrained data types; and combinations thereof.
 8. The AI engine of claim 7, wherein each connector of a number of connectors between the connected nodes of the mental model includes a data type, and wherein the mental-model designer is further configured to color code the number of connectors in the mental model to indicate whether the data type between the connected nodes of the mental model is correct or not for each connector.
 9. The AI engine of claim 1, wherein the architect module is further configured to map the one or more concept nodes of the mental model on the one or more neural-network layers of the AI model, and wherein the instructor module is further configured to find a starting point among the one or more concept nodes and the one or more curriculums for training the AI model.
 10. The AI engine of claim 9, wherein the instructor module is further configured to train the AI model in one or more training cycles with training data from one or more training-data sources selected from a simulator, a training-data generator, a training-data database, or a combination thereof based on training parameters in the source code, and wherein the instructor module is further configured to terminate neural-network training upon an instructor module-determined terminating condition.
 11. An artificial intelligence (“AI”) system including an AI engine configured with multiple user interfaces to accommodate different types of users solving different types of problems with AI, comprising: a) one or more remote servers including i) a compiler in a server memory, wherein the compiler, upon execution of the compiler by one or more server processors, is configured to generate an assembly code from a source code written in a pedagogical programming language, and wherein the compiler is further configured to receive the source code through an application programming interface (“API”) exposed to the multiple user interfaces; and ii) one or more AI-engine modules in the server memory including an architect module, an instructor module, and a learner module, wherein the architect module, upon execution of the architect module by the one or more server processors, is configured to propose a neural-network layout with one or more neural-network layers from the assembly code, wherein the learner module, upon execution of the learner module by the one or more server processors, is configured to build an AI model with the one or more neural-network layers from the neural-network layout proposed by the architect module, and wherein the instructor module, upon execution of the instructor module by the one or more server processors, is configured to train the AI model built by the learner module on a mental model defined in the source code; and b) one or more local clients including i) the multiple user interfaces in one or more client memories, wherein the multiple user interfaces enable an author to define the mental model for the AI model to learn and one or more curriculums written in the pedagogical programming language, the mental model including an input, one or more concept nodes, and an output, wherein each user interface of the multiple user interfaces is selected from an integrated development environment (“IDE”), a web-browser interface, and a command-line interface (“CLI”), and wherein the multiple user interfaces further enable the author to send the source code through the API exposed to the multiple user interfaces to the compiler.
 12. A non-transitory machine-readable medium configured to store data and instructions, which, when executed by one or more processors on a computing device, causes the following operations, comprising: receiving a source code through an application programming interface (“API”) exposed to multiple user interfaces, wherein the multiple user interfaces enable an author to define a mental model for an AI model to learn and one or more curriculums written in a pedagogical programming language, the mental model including an input, one or more concept nodes, and an output, and wherein the multiple user interfaces further enable the author to send the source code through the API exposed to the multiple user interfaces; generating an assembly code from the source code with a compiler of an artificial intelligence (“AI”) engine configured to work with the multiple interfaces; proposing a neural-network layout including one or more neural-network layers from the assembly code with an architect AI-engine module of the AI engine; building the AI model including the one or more neural-network layers from the neural-network layout with a learner AI-engine module of the AI engine; and training the AI model on the mental model with an instructor AI-engine module of the AI engine.
 13. The machine-readable medium of claim 12, wherein each user interface of the multiple user interfaces is selected from an integrated development environment (“IDE”), a web-browser interface, and a command-line interface (“CLI”), wherein the different types of users solving the different types of problems with AI are users having different levels of programming skills solving different problems with AI at least commensurate with the different levels of programming skills, and wherein the IDE, the web-browser interface, and the CLI are designed to accommodate the users having the different levels of programming skills.
 14. The machine-readable medium of claim 13, wherein the multiple user interfaces include the CLI, and wherein the machine-readable medium further comprises enabling the author to send the source code to the compiler through the API exposed to the CLI, configure aspects of training the AI model, and connect the AI model to a simulator for the training.
 15. The machine-readable medium of claim 13, wherein the multiple user interfaces include the web-browser interface, and wherein the machine-readable medium further comprises enabling the author to send the source code to the compiler through the API exposed to the web-browser interface, provide a name and description for a trained AI model prior to training the AI model, and indicate a data storage for testing data the trained AI model can execute subsequent to training the AI model.
 16. The machine-readable medium of claim 13, wherein the one of the multiple user interfaces is the IDE, the IDE including a text editor and a mental-model designer, wherein a first author-based modification of the mental model in the text editor automatically replicates the first author-based modification of the mental model in the mental-model designer, wherein a second author-based modification of the mental model in the mental model designer automatically replicates the second author-based modification of the mental-model in the text editor, and wherein the machine-readable medium further comprises enabling the author to define the mental model by typing in a textual mode in the text editor, gesturing in a graphical mode in the mental-model designer, or a combination thereof.
 17. The machine-readable medium of claim 16, further comprising enabling the author in the text editor to set one or more breakpoints in the source code written in the pedagogical programming language in the text editor; and automatically highlighting in the mental-model designer the one or more concept nodes of the mental model corresponding to the one or more breakpoints if the one or more breakpoints are set at the one or more concept nodes.
 18. The machine-readable medium of claim 16, wherein each connector of a number of connectors between connected nodes of the mental model including the one or more concept nodes includes a data type selected from primitive data types including from strings, integers, floats, and Booleans; structured data types; constrained data types including range expressions limiting the data of the constrained data types; and combinations thereof, and wherein the machine-readable medium further comprises color coding the number of connectors of the mental model in the mental-model designer to indicate whether the data type between the connected nodes of the mental model is correct or not for each connector.
 19. The machine-readable medium of claim 12, further comprising mapping with the architect module the one or more concept nodes of the mental model on the one or more neural-network layers of the AI model; and finding with the instructor module a starting point among the one or more concept nodes and the one or more curriculums for training the AI model.
 20. The machine-readable medium of claim 19, further comprising training the AI model with the instructor module in one or more training cycles with training data from one or more training-data sources selected from a simulator, a training-data generator, a training-data database, or a combination thereof based on training parameters in the pedagogical programming language, and terminating the training of the AI model upon an instructor module-determined terminating condition. 